home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / AHDI / SYQUEST / SQHDX / BSL.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  19.0 KB  |  671 lines
  1. /*
  2.  * BSL.C
  3.  *
  4.  *     Functions to manipulate the Bad Sector List.
  5.  *
  6.  * 25-Nov-87    ml.    Started this mess.
  7.  * 04-Dec-87    ml.    Hmmm, looks OK.
  8.  * 11-Dec-87    ml.    Added bsl2fat().
  9.  * 14-Dec-87    ml.    Structure of BSL is changed (_again_!).
  10.  *            Now, first entry in BSL contains number VENDOR
  11.  *            entries.  First byte of 2nd entry is the checksum
  12.  *            byte, while 2nd and 3rd bytes are reserved for 
  13.  *            future use.
  14.  *
  15.  */
  16.  
  17. #include "obdefs.h"
  18. #include "osbind.h"
  19. #include "defs.h"
  20. #include "part.h"
  21. #include "bsl.h" 
  22. #include "hdx.h"
  23. #include "addr.h" 
  24. #include "error.h" 
  25.  
  26. /* Globals */
  27. BYTE *bsl;            /* bad sector list */
  28. long bslsiz;            /* num sectors BSL occupies */
  29. SECTOR badbuf[WARNBADSECTS];    /* bad sectors buffer */
  30. extern int format;        /* 1: called by Format */
  31.  
  32.  
  33. /*
  34.  *  Get size of the Bad Sector List (in sectors)
  35.  *    Input:
  36.  *        pdev - physical unit BSL belongs to.
  37.  *    Return:
  38.  *        number of sectors BSL occupies.
  39.  */
  40. long 
  41. gbslsiz(pdev) 
  42. int pdev;    /* physical device number */
  43. {
  44.     char bs[512];    /* boot sector image */
  45.     UWORD  ret;
  46.     
  47.     if ((ret = getroot(pdev, bs)) != 0) {
  48.         if (tsterr(ret) == OK)
  49.         return MDMERR;
  50.     else return ERROR;
  51.     }
  52.     
  53.     if (((RSECT *)(bs + 0x200 - sizeof(RSECT)))->bsl_st != STBSL)
  54.         return 0L;
  55.         
  56.     return(((RSECT *)(bs + 0x200 - sizeof(RSECT)))->bsl_cnt);
  57. }
  58.  
  59.  
  60. /*
  61.  *  Set BSL parameters (starting sector and size of BSL) into
  62.  *  root sector image.
  63.  *    Input:
  64.  *        image - root sector image.
  65.  */
  66. sbslparm(image)
  67. char *image;
  68. {
  69.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->bsl_st = STBSL;
  70.     ((RSECT *)(image + 0x200 - sizeof(RSECT)))->bsl_cnt = bslsiz;
  71. }
  72.  
  73.  
  74. /* 
  75.  *  Create a BSL in memory.
  76.  *    Input:
  77.  *        pdev - physical unit BSL will belong to.
  78.  *        type - kind of BSL to be created. NEW or EXPAND.
  79.  *        nents - number of VENDOR entries BSL should hold.
  80.  *    Output:
  81.  *        bsl - pointer to the BSL. (in bsl.h)
  82.  *    Return:
  83.  *        OK - everything is fine.
  84.  *        ERROR - anything is wrong.
  85.  *    Comment:
  86.  *        "NEW" means to create a totally new BSL.
  87.  *        "EXPAND" means to expand an existing BSL.
  88.  */
  89. creabsl(pdev, type, nents)
  90. int  pdev;    /* physical unit number */
  91. int  type;    /* kind of BSL to be created */
  92. long  nents;    /* num VENDOR entries in BSL */
  93. {
  94.     BYTE *newbsl;  /* BSL just created */
  95.     long l, size;  /* l - index into BSL;  size - size of BSL in bytes */ 
  96.     long start;       /* where to start initializing entries to zeroes */
  97.     long nument();
  98.  
  99.     if (nents == 0) {    /* no VENDOR entries specified */
  100.         size = 512L;    /* default size of BSL to 1 sector */
  101.     } else {       /* num VENDOR entries is specified */
  102.         /*------------------------------------------------------*/
  103.         /* Calculate length of BSL in bytes.            */
  104.         /* Have to add space for reserved entries and USER list    */
  105.         /* (note: (+1) to round up)                */
  106.         /*------------------------------------------------------*/
  107.     size = (((nents + RENT + WARNBADSECTS)/EPS) + 1) * 512L;
  108.     }
  109.     
  110.     /* allocate enough memory for new BSL */
  111.     if ((newbsl = (BYTE *)mymalloc((int)size)) <= 0)
  112.         return err(nomemory);
  113.     
  114.     if (type == NEW) {    /* a new BSL */
  115.         start = 0;    /* start at 0th entry, i.e. init whole BSL to 0s */
  116.     }    
  117.     else {        /* expand the BSL */
  118.         /* start init to 0s after VENDOR list */
  119.     start = (nument(VENDOR) + RENT) * BPE;
  120.     
  121.         /* copy original BSL into this expanded memory */
  122.         for (l = 0; l < start; l++)
  123.             newbsl[l] = bsl[l];
  124.     }
  125.         
  126.             
  127.     /* free up old BSL */
  128.     if (bsl > 0) free(bsl);
  129.     bsl = newbsl;
  130.     
  131.     /* init BSL to zeroes beginning at 'start'th entry */
  132.     for (l = start; l < size; l++)
  133.         bsl[l] = 0;
  134.         
  135.     /* install BSL info */
  136.     bslsiz = size/512;    /* current num sectors BSL occupies */
  137.     put3bytes(bsl, nents);  /* num VENDOR entries */
  138.     mkmagic();    /* make the BSL checks sum to BSLMAGIC byte-wise */
  139.                           
  140.     return OK;
  141. }
  142.  
  143.  
  144. /*
  145.  *  Read the BSL into memory.
  146.  *    Input:
  147.  *        pdev - physical unit that contains the BSL.
  148.  *    Output:
  149.  *        bsl - pointer to the BSL.  (in bsl.h)
  150.  *    Return:
  151.  *        OK - everything is fine.
  152.  *        INVALID - BSL doesn't checksum correctly.
  153.  *        ERROR - can't read BSL.
  154.  */
  155. rdbsl(pdev)
  156. int pdev;    /* physical unit to read from */
  157. {
  158.     int ret;
  159.     
  160.     if ((ret = rdsects(pdev, (UWORD)bslsiz, bsl, (SECTOR)STBSL)) != 0) {
  161.         if (tsterr(ret) != OK) {
  162.             if (format == FALSE)
  163.             err(bslread);
  164.     }
  165.     return ERROR;
  166.     }
  167.         
  168.     return(sumbsl());    /* Checksum BSL and return */
  169. }
  170.  
  171.  
  172. /*
  173.  *  Count number of entries in the requested portion of BSL.
  174.  *    Input:
  175.  *        portion - portion of BSL.  MEDIA, VENDOR, USER or UNUSED.
  176.  *    Return:
  177.  *        Number of entries of the requested portion.
  178.  *    Comments:
  179.  *        There are 3 bytes per entry (BPE), and the first 2 entries
  180.  *    are reserved (RENT) for BSL info.
  181.  */
  182. long
  183. nument(portion)
  184. int portion;        /* portion of BSL to be counted */
  185. {
  186.     long  vdr, usr;        /* num ent in VENDOR list, num ent in USER list */
  187.     long  nbytes, offset;   /* BSL's len in bytes, index into BSL */
  188.     long  get3bytes();
  189.     
  190.     /* 1st entry in BSL contains num entries in VENDOR list */
  191.     vdr = get3bytes(bsl);
  192.     
  193.     if (portion == VENDOR)  return (vdr);
  194.     
  195.     nbytes = bslsiz*512;    /* num bytes in BSL */
  196.     
  197.     /* num bytes available for valid entries */
  198.     /* (need this because nbytes may not be divisible by BPE) */
  199.     nbytes -= (nbytes % BPE);
  200.     
  201.     /* find out num entries in USER list */
  202.     usr = 0;
  203.     for (offset = (RENT+vdr)*BPE;  /* index into beginning of USER list */
  204.          (offset < nbytes)       /* while not at end of BSL */
  205.      && get3bytes(bsl+offset); /* and it's a used entry */
  206.          offset += BPE)           /* increment index */
  207.         usr++;        /* increment num entries for USER list */
  208.          
  209.     if (portion == USER)
  210.         return (usr);        /* num entries in USER list */
  211.         
  212.     if (portion == MEDIA)
  213.         return (vdr+usr);    /* num entries in MEDIA list */     
  214.         
  215.     /* portion == UNUSED */
  216.     return ((nbytes/BPE)-RENT-vdr-usr);
  217. }
  218.  
  219.  
  220. /*
  221.  *  Write the BSL into the disk.
  222.  *    Input:
  223.  *        pdev - physical unit number BSL belongs to.
  224.  *        bsl - pointer to buffer containing the BSL. (in bsl.h)
  225.  *    Return:
  226.  *        OK - everything is fine.
  227.  *        ERROR - can't write BSL.
  228.  */
  229. wrbsl(pdev)
  230. int pdev;    /* physical unit number */
  231. {
  232.     int ret;            /* return code */
  233.     
  234.     if ((ret = wrsects(pdev, (UWORD)bslsiz, bsl, (SECTOR)STBSL)) != 0) {
  235.         if (tsterr(ret) != OK)
  236.             err(bslwrite);
  237.         return ERROR;
  238.     }
  239.  
  240.     return OK;
  241. } 
  242.  
  243.  
  244. /*
  245.  *  Sort the BSL in memory in ascending order.
  246.  *    Input:
  247.  *        entries - number of used entries in BSL
  248.  *        bsl - pointer to the BSL. (in bsl.h)
  249.  *    Output:
  250.  *        a sorted bsl.
  251.  *    Algorithm:
  252.  *        Bubble sort.
  253.  *    Comments:
  254.  *        The reserved entries won't be sorted.
  255.  */
  256. sortbsl(entries)
  257. long  entries;    /* num entries in BSL */
  258. {
  259.     long  i, e1, e2;
  260.     long  start;    /* beginning byte of entries in BSL */
  261.     long  end;        /* tail byte of BSL */
  262.     int   change;    /* signal if changes have been made in current pass */
  263.     long  get3bytes();
  264.     
  265.     if (entries == 0L || entries == 1L)    /* BSL is empty */
  266.         return;
  267.             
  268.     change = 1;        /* assume list is not in order */
  269.     start = RENT*BPE;    /* beginning of entries in BSL */
  270.     end = entries * BPE;
  271.     while (1) {
  272.         if (change == 0)    /* if no changes made, DONE --> HOME */
  273.         return;
  274.         
  275.         change = 0;    /* assume list is in order */
  276.         for (i = start; i <= end; i += BPE) {
  277.             e1 = get3bytes(bsl+i);
  278.             e2 = get3bytes(bsl+i+BPE);
  279.             if (e1 > e2) {            /* switch if out of order */
  280.                 put3bytes(bsl+i, e2);
  281.                 put3bytes(bsl+i+BPE, e1);
  282.                 change = 1;
  283.             }
  284.         }
  285.         end -= BPE;
  286.     }
  287. }
  288.  
  289.  
  290. /*
  291.  *  Search through a sorted BSL for a given sector number.
  292.  *    Input:
  293.  *        sect - sector number searching for.
  294.  *        entries - number of used entries in the BSL.
  295.  *    Return:
  296.  *        YES - if given sector is found.
  297.  *        NO - if given sector is not found.
  298.  *    Algorithm:
  299.  *        Binary Search.
  300.  */
  301. srchbsl(sect, entries)
  302. SECTOR  sect;    /* sector searching for */
  303. long  entries;    /* num used entries in BSL */
  304. {
  305.     long  start, mid, end; /* start, middle and end indices into list */
  306.     SECTOR  temp;       /* sector number in middle of list */
  307.     long  get3bytes();
  308.  
  309.     start = RENT;        /* start after reserved entries */
  310.     end = entries+RENT-1;    /* end of BSL */ 
  311.     
  312.     while (1) {
  313.          mid = (start + end) / 2;        /* middle entry in list */
  314.         temp = get3bytes(bsl+(mid*BPE));    /* sector num at mid entry */
  315.         
  316.         if (sect == temp)    /* given sector == sector at mid entry */
  317.             return YES;        /* given sector found in list */
  318.         else if (sect < temp)    /* given sector < sector at mid entry */
  319.             end = mid - 1;    /* limit search to smaller sector num */
  320.         else            /* given sector > sector at mid entry */
  321.             start = mid + 1;    /* limit search to larger sector num */
  322.             
  323.         if (end < start)    /* list is exhausted */
  324.             return NO;        /* can't find given sector */    
  325.     }
  326. }
  327.  
  328.  
  329. /*
  330.  *  Checksum (byte-wise) the BSL.
  331.  *    Input:
  332.  *        bsl - pointer to the BSL.  (in bsl.h)
  333.  *    Return:
  334.  *        OK - BSL checksum to BSLMAGIC (0xa5).
  335.  *        INVALID - BSL does not checksum to BSLMAGIC.
  336.  */
  337. sumbsl()
  338. {
  339.     register BYTE sum;    /* byte-wise sum of BSL */
  340.     long i;        /* index into BSL */
  341.     long length;    /* length of BSL in bytes */
  342.  
  343.     length = bslsiz*512;    /* length of entire BSL */
  344.     sum = 0;    /* initialize the sum */
  345.     
  346.     /* Sum up values in the BSL by byte */
  347.     for (i = 0; i < length; i++) {
  348.         sum += bsl[i];
  349.     }
  350.     if (sum != BSLMAGIC) {    /* doesn't checksum correctly */
  351.         return INVALID;
  352.     }
  353.     return OK;    /* checksum correctly */
  354. }
  355.  
  356.  
  357. /*
  358.  *  Make the BSL checks sum to BSLMAGIC.
  359.  */
  360. mkmagic()
  361. {
  362.     register BYTE diff;    /* difference to make BSL checks sum correctly */
  363.     long i;        /* index into BSL */
  364.     long len;        /* length of BSL in bytes */
  365.     
  366.     len = bslsiz*512;    /* length of entire BSl */
  367.     diff = BSLMAGIC;    /* initialize the difference */
  368.     
  369.     /* find out what number would make BSL checks sum to BSLMAGIC */
  370.     for (i = 0; i < len; i++) {
  371.         diff -= bsl[i];
  372.     }
  373.     
  374.     /* add that difference to checksum byte (1st byte of 2nd entry of BSL) */
  375.     bsl[BPE] += diff;
  376. }
  377.  
  378.  
  379. /*
  380.  *  Add bad sectors found to the Bad Sector List.
  381.  *    Input:
  382.  *        pdev - physical unit BSL belongs to.
  383.  *        portion - portion of BSL to add to.  VENDOR or USER.
  384.  *        nbad - number of bad sectors to be added.
  385.  *    Return:
  386.  *        toadd - number of new bad sectors added to the BSL.
  387.  *        USRFULL - user part of the BSL is filled up.
  388.  *        NOMEM - not enough memory for add buffer or BSL.
  389.  *        ERROR - something is wrong.
  390.  *    Comment:
  391.  *        The entry will be added only if it is not already on the
  392.  *    bad sector list.  Binary search is performed to guarantee this.
  393.  *        If the VENDOR list is full, this routine will take care
  394.  *    of the expansion of the list also.
  395.  */
  396. addbsl(pdev, portion, nbad) 
  397. int pdev;        /* physical unit number */
  398. int portion;        /* portion of BSL */
  399. int nbad;        /* num of bad sectors to be added */
  400. {
  401.     long  entries;    /* num entries to be retained in BSL */
  402.     long  empty;    /* num empty slots available for adding entries */
  403.     long  end;        /* address of end of BSL */
  404.     int  i, toadd;    /* index to badbuf, num of bad sectors to be added */
  405.     int  ret = 0;    /* return code */
  406.     SECTOR *addbuf;    /* bad sectors to be added to BSL */
  407.     long  nument();
  408.     
  409.     /* Allocate memory for sector numbers of bad sectors to be added */
  410.     if ((addbuf = (SECTOR *)mymalloc(nbad*4)) <= 0) {
  411.         err(nomemory);
  412.         return NOMEM;
  413.     }
  414.     
  415.     if (portion == VENDOR) {    /* adding to VENDOR list */
  416.         entries = nument(VENDOR);   /* only keep the VENDOR list */
  417.         empty = 0;            /* there's no unused slot for VENDOR ent */
  418.     } else {            /* adding to USER list */
  419.         entries = nument(MEDIA);    /* keep entire list */
  420.         empty = nument(UNUSED);     /* slots left unused */
  421.     }
  422.     sortbsl(entries);        /* sort BSL in ascending order */
  423.     toadd = 0;            /* none is to be added to BSL yet */
  424.  
  425.     /* For all bad sectors found, search for them in the current BSL.
  426.        Add them to the list only when they are not already recorded.  */    
  427.     if (entries) {    /* only search if BSL is not empty */
  428.     for (i = 0; i < nbad; i++) {
  429.         if (srchbsl(badbuf[i], entries) == NO) {
  430.         addbuf[toadd] = badbuf[i];
  431.         toadd++;
  432.         }
  433.         }
  434.     } else {  /* add in all bad sectors found */
  435.     for (i = 0; i < nbad; i++)
  436.         addbuf[i] = badbuf[i];
  437.         toadd = nbad;
  438.     }
  439.     
  440.     /* All bad sectors found have been recorded.  Nothing is added to BSL */
  441.     if (toadd == 0) {
  442.         if (portion == USER && (ret = rdbsl(pdev)) != OK) {
  443.             if (ret == INVALID)
  444.                 err(cruptbsl);
  445.         goto togo;
  446.     }
  447.         ret = toadd;
  448.     }
  449.     
  450.     /*------------------------------------------------------------------*/
  451.     /* Check if there are enough empty slots for new entries.  If not,    */
  452.     /* determine what kind of entries we are adding, VENDOR or USER.    */    
  453.     /* Expand the BSL if we are adding to VENDOR list.  Give warning    */
  454.     /* if we are adding to USER list.                          */
  455.     /*------------------------------------------------------------------*/
  456.     if (toadd > empty) {
  457.         if (portion == VENDOR) {    /* this only happens at format time */
  458.         /* expanded BSL should hold (entries + toadd) VENDOR entries */
  459.         if (creabsl(pdev, EXPAND, entries+toadd) != OK)
  460.             goto togo;
  461.         } else {            /* We are adding to USER list */
  462.             err(manybad);
  463.             toadd = empty;    /* num ent to add = empty slots available */
  464.         }
  465.     }
  466.     
  467.     /* Read in orig unsorted list if adding USER entries */
  468.     if (portion == USER) {
  469.         if ((ret = rdbsl(pdev)) != OK) {
  470.             if (ret == INVALID)
  471.                 err(cruptbsl);
  472.             goto togo;
  473.         }
  474.     }
  475.                 
  476.     /* Append new entries to end of BSL */
  477.     end = bsl + (RENT + entries)*BPE;    /* end of BSL */
  478.     for (i = 0; i < toadd; i++) {
  479.         put3bytes((end + i*BPE), addbuf[i]);
  480.     }
  481.     
  482.     /* make BSL checks sum to magic number */
  483.     mkmagic();
  484.  
  485.     if (portion == USER && toadd == empty) {
  486.         ret = USRFULL;
  487.         goto togo;
  488.     }
  489.         
  490.     ret = toadd;
  491.     
  492. togo:
  493.     if (addbuf > 0) free(addbuf);            
  494.     return(ret);
  495. }
  496.  
  497.  
  498. /*
  499.  *  Mark bad sectors from the BSL to FATs of a partition.
  500.  *    Input:
  501.  *        ldev - logical device the FATs belong to.
  502.  *        fat0 - logical sector number of where FAT 0 starts.
  503.  *        fatsiz - size of FAT in sectors.
  504.  *        data - logical sector number of where data clusters start.
  505.  *        portion - part of BSL to mark from.
  506.  */
  507. bsl2fat(ldev, fat0, fatsiz, data, portion)
  508. int  ldev;    /* logical device number */
  509. SECTOR fat0;    /* starting sector number (logical) of FAT 0 */ 
  510. UWORD fatsiz;    /* FAT size */
  511. SECTOR data;    /* starting sector number (logical) of data clusters */
  512. int portion;    /* part of BSL to mark from, VENDOR or MEDIA */
  513. {
  514.     long nument(), entries;    /* num entries in the list to be considered */
  515.     long i, end;        /* indices to the list to be considered */
  516.     SECTOR badsect;        /* a bad sector in the list */
  517.     SECTOR pstart;        /* phys sector num where partition starts */
  518.     SECTOR pdata;        /* phys sector num where data block starts */
  519.     SECTOR pend;        /* phys sector num where data block ends */
  520.     SECTOR logstart(), logend();
  521.     int nbad;
  522.     
  523.     nbad = 0;            /* assume none to be marked */
  524.     pstart = logstart(ldev);    /* find where partition starts */
  525.     pdata = pstart + data;    /* find where data block starts */
  526.     pend = logend(ldev);    /* find where data block ends */    
  527.     entries = nument(portion);    /* find num entries in given portion */
  528.     sortbsl(entries);        /* sort given portion of BSL */
  529.     
  530.     end = (RENT + entries) * BPE;
  531.     
  532.     /* Store vendor bad sectors of the logical device in badbuf */
  533.     for (i = BPE*RENT; i < end; i += BPE) {
  534.         if ((badsect = get3bytes(bsl+i)) > pend)
  535.             break;
  536.             
  537.         if (badsect >= pdata) {
  538.             badbuf[nbad++] = badsect;
  539.             
  540.             /* if badbuf overflows, mark what we have so far in the FAT */
  541.             if (nbad == WARNBADSECTS) {
  542.                 if (fixbadcls(ldev, fat0, fatsiz, data, nbad) < 0) {
  543.                     return ERROR;
  544.                 }
  545.                 nbad = 0;    /* reinit num bad sectors in partition to 0 */
  546.             }
  547.         }
  548.     }
  549.     
  550.     /* Bad sectors in partition not marked in FAT yet */
  551.     if (nbad) {
  552.         if (fixbadcls(ldev, fat0, fatsiz, data, nbad) < 0) {
  553.             return ERROR;
  554.         }
  555.     }
  556.     
  557.     return OK;
  558. }
  559.  
  560.  
  561. /*
  562.  *  Count number of bad sectors on a logical drive recorded in BSL.
  563.  *    Input:
  564.  *        ldev - logical drive to be considered.
  565.  *    Return:
  566.  *        nbad - number of bad sectors found.
  567.  */
  568. long
  569. cntbad(ldev)
  570. int  ldev;    /* logical drive number */
  571. {
  572.     SECTOR pstart, pend;    /* phys starting and ending block of ldev */
  573.     extern SECTOR logstart(), logend();
  574.     long nbad=0L;        /* num bad sectors on ldev */
  575.     long entries, nument(), bslend;
  576.     long curr, get3bytes();
  577.     int done, i;
  578.     
  579.     pstart = logstart(ldev);    /* starting block # of partition */
  580.     pend = logend(ldev);    /* ending block # of partition */
  581.     entries = nument(MEDIA);    /* num entries in BSL */
  582.     sortbsl(entries);        /* sort BSL */
  583.     
  584.     done = 0;
  585.     bslend = (RENT+entries) * BPE;
  586.     for (i = RENT*BPE; (!done) && (i < bslend); i += BPE) {
  587.         curr = get3bytes(bsl+i);  /* get next entry in BSL */
  588.         if (curr < pstart)      /* not within logical drive's range yet */
  589.             continue;
  590.         if (curr <= pend)      /* within logical drive's range */
  591.             nbad++;
  592.         else done = 1;          /* pass logical drive's range */
  593.     }
  594.     return (nbad);
  595. }
  596.  
  597.  
  598. /*
  599.  *  Put a word into memory in 68000 format.
  600.  *    Input:
  601.  *        p - pointer to memory.
  602.  *        i - word to be put.
  603.  */
  604. putword(p, i)
  605. BYTE *p;
  606. UWORD i;
  607. {
  608.     *p = i >> 8;
  609.     *(p+1) = i;
  610. }
  611.  
  612.  
  613. /*
  614.  *  Get a 68000 format word from memory.
  615.  *    Input:
  616.  *        p - pointer to memory.
  617.  *    Return:
  618.  *        i - word read from memory.
  619.  */        
  620. getword(p)
  621. BYTE *p;
  622. {
  623.     UWORD i;
  624.     
  625.     i = *p;
  626.     i <<= 8;
  627.     i |= *(p+1);
  628.     return (i);
  629. }
  630.  
  631.  
  632. /*
  633.  *  Put 3 bytes (68000 format) into memory.
  634.  *    Input:
  635.  *        p - pointer to memory.
  636.  *        l - long which contains the 3 bytes at the low-bit end.
  637.  */
  638. put3bytes(p, l)
  639. BYTE *p;
  640. long l;
  641. {
  642.     *p = l >> 16;
  643.     *(p+1) = l >> 8;
  644.     *(p+2) = l;
  645. }    
  646.  
  647.  
  648. /*
  649.  *  Get 3 bytes (68000 format) from memory.
  650.  *    Input:
  651.  *        p - pointer to memory.
  652.  *    Return:
  653.  *        l - a long which contains the 3 bytes read in last 3 bytes.
  654.  */
  655. long
  656. get3bytes(p)
  657. BYTE *p;
  658. {
  659.     long  k=0x000000ff, l=0x000000ff;
  660.     
  661.     l &= *p;        /* first byte */
  662.     l <<= 16;
  663.     k &= *(p+1);    /* second byte */
  664.     k <<= 8;
  665.     l |= k;
  666.     k = 0x000000ff;
  667.     k &= *(p+2);    /* third byte */
  668.     l |= k;
  669.     return (l);
  670. }
  671.